// ---------------------------------------
// Template: cls.cs	rel: 3.0.0.0 NoDal
// ---------------------------------------
using System;
using System.Data;
using IGCal.Collections;
using IGCal.Funzioni;
using IGCal.DB;

namespace DefaultDirigenti
{
	/// <summary>
	/// Middle tier per accedere alla tabella DefaultDirigenti
	/// </summary>
	public class DefaultDirigenteCollection : IGCalDictionaryBase
	{

		/// <summary>
		/// Crea una nuova istanza della collection
		/// </summary>
		public DefaultDirigenteCollection()
		{
		}

		/// <summary>
		/// Recupera DefaultDirigent dalla collection
		/// </summary>
		public DefaultDirigente this[int IDDirigente, int IDRuoloDirigenteInGara, bool Casa]
		{
			get
			{
				DefaultDirigente DefaultDirigent = new DefaultDirigente();
				
				DefaultDirigent.IDDirigente = IDDirigente;
				DefaultDirigent.IDRuoloDirigenteInGara = IDRuoloDirigenteInGara;
				DefaultDirigent.Casa = Casa;
				
				
				DefaultDirigent = (DefaultDirigente) InnerHashtable[DefaultDirigent];

				return DefaultDirigent;
			}
		}

		/// <summary>
		/// Rigenera la collection leggendo dalla tabella DefaultDirigenti
		/// </summary>
		/// <param name="connection">Connessione al database da cui leggere</param>
		/// <param name="sqlWhere">Clausola where da utilizzare nella query (null o "" per leggere tutti i record)</param>
		public void Refresh(Connection connection, string sqlWhere)
		{
			InnerHashtable.Clear();

			DataTable dataTable;
			DefaultDirigente DefaultDirigent;

			string sql = GetQuery(sqlWhere);

			dataTable = connection.GetDataTable(sql);

			foreach (DataRow row in dataTable.Rows)
			{
				DefaultDirigent = new DefaultDirigente();
				DefaultDirigent.ReadFromRow(row);
				InnerHashtable.Add(DefaultDirigent, DefaultDirigent);
			}
		}

		/// <summary>
		/// Recupera DefaultDirigent dalla tabella DefaultDirigenti
		/// </summary>
		/// <param name="connection">Connessione al database da cui leggere</param>
		/// <param name="IDDirigente">IDDirigente</param>
		/// <param name="IDRuoloDirigenteInGara">IDRuoloDirigenteInGara</param>
		/// <param name="Casa">Casa</param>
		/// <returns>DefaultDirigent</returns>
		public static DefaultDirigente Read(Connection connection, int IDDirigente, int IDRuoloDirigenteInGara, bool Casa)
		{
			DefaultDirigente DefaultDirigent;

			DataRow row;

			try
			{
				row = GetRecord(connection, null, IDDirigente, IDRuoloDirigenteInGara, Casa);
			}
			catch
			{
				return null;
			}

			DefaultDirigent = new DefaultDirigente();
			DefaultDirigent.ReadFromRow(row);
			return DefaultDirigent;
		}

		/// <summary>
		/// Inserisce l'elemento nella tabella
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="DefaultDirigent">Elemento da inserire nella tabella</param>
		public static void Insert(Connection connection, DefaultDirigente DefaultDirigent)
		{
			string SQL = GetQuery("1 = 2");
			DataAdapter dataAdapter = connection.GetDataAdapter();
			DataTable dataTable = connection.GetDataTable(dataAdapter, SQL);

			DataRow row = dataTable.NewRow();
			DefaultDirigent.WriteToRow(row);
			dataTable.Rows.Add(row);

			dataAdapter.Update(dataTable);

			dataAdapter.Dispose();
		}

		/// <summary>
		/// Aggiorna l'elemento nella tabella. Con questo metodo non � possibile aggiornare la primary key
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="DefaultDirigent">Elemento da aggiornare nella tabella</param>
		public static void Update(Connection connection, DefaultDirigente DefaultDirigent)
		{
			Update(connection, DefaultDirigent.IDDirigente, DefaultDirigent.IDRuoloDirigenteInGara, DefaultDirigent.Casa, DefaultDirigent);
		}

		/// <summary>
		/// Aggiorna l'elemento identificato con i campi chiave specificati nella tabella
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="IDDirigente">IDDirigente</param>
		/// <param name="IDRuoloDirigenteInGara">IDRuoloDirigenteInGara</param>
		/// <param name="Casa">Casa</param>
		/// <param name="DefaultDirigent">Elemento da aggiornare nella tabella</param>
		public static void Update(Connection connection, int IDDirigente, int IDRuoloDirigenteInGara, bool Casa, DefaultDirigente DefaultDirigent)
		{
			DataAdapter dataAdapter = connection.GetDataAdapter();

			DataRow row = GetRecord(connection, dataAdapter, IDDirigente, IDRuoloDirigenteInGara, Casa);
			DefaultDirigent.WriteToRow(row);

			dataAdapter.Update(row.Table);

			dataAdapter.Dispose();
		}

		/// <summary>
		/// Elimina l'elemento dalla tabella
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="DefaultDirigent">Elemento da eliminare dalla tabella</param>
		public static void Delete(Connection connection, DefaultDirigente DefaultDirigent)
		{
			Delete(connection, DefaultDirigent.IDDirigente, DefaultDirigent.IDRuoloDirigenteInGara, DefaultDirigent.Casa);
		}

		/// <summary>
		/// Elimina l'elemento nella tabella
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="IDDirigente">IDDirigente</param>
		/// <param name="IDRuoloDirigenteInGara">IDRuoloDirigenteInGara</param>
		/// <param name="Casa">Casa</param>
		public static void Delete(Connection connection, int IDDirigente, int IDRuoloDirigenteInGara, bool Casa)
		{
			DataAdapter dataAdapter = connection.GetDataAdapter();

			DataRow row = GetRecord(connection, dataAdapter, IDDirigente, IDRuoloDirigenteInGara, Casa);

			row.Delete();

			dataAdapter.Update(row.Table);

			dataAdapter.Dispose();
		}

		/// <summary>
		/// Costruisce la query sulla tabella
		/// </summary>
		/// <param name="SQLWhere">Clausola where da utilizzare nella query (null o string.Empty per leggere tutti i record)</param>
		/// <returns>La query</returns>
		private static string GetQuery(string SQLWhere)
		{
			if (SQLWhere == null || SQLWhere == string.Empty)
				return "Select * From DefaultDirigenti";
			else
				return "Select * From DefaultDirigenti Where " + SQLWhere;
		}

		/// <summary>
		/// Recupera un record dalla tabella (se non c'e' o ce ne sono piu' di uno viene rilanciata un'eccezione)
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="dataAdapter">DataAdapter nel caso in cui la tabella debba essere aperta in scrittura</param>
		/// <param name="IDDirigente">IDDirigente</param>
		/// <param name="IDRuoloDirigenteInGara">IDRuoloDirigenteInGara</param>
		/// <param name="Casa">Casa</param>
		/// <returns>La DataRow relativa al record</returns>
		private static DataRow GetRecord(Connection connection, DataAdapter dataAdapter, int IDDirigente, int IDRuoloDirigenteInGara, bool Casa)
		{
			string SQLWhere = null;
			DataTable dataTable;

			SQLWhere += string.Format(" And IDDirigente = {0}", IDDirigente);
			SQLWhere += string.Format(" And IDRuoloDirigenteInGara = {0}", IDRuoloDirigenteInGara);
			SQLWhere += string.Format(" And Casa = '{0}'", General.RaddoppiaVirgolette(Casa.ToString()));

			string SQL = GetQuery(SQLWhere.Substring(4));

			if (dataAdapter != null)
				dataTable = connection.GetDataTable(dataAdapter, SQL);
			else
				dataTable = connection.GetDataTable(SQL);

			if (dataTable.Rows.Count == 0)
				throw new Exception("Record non trovato");

			if (dataTable.Rows.Count > 1)
				throw new Exception("La chiave primaria non identifica solo un record");

			return dataTable.Rows[0];
		}
	}







	/// <summary>
	/// Middle tier per accedere ad un record della tabella DefaultDirigenti
	/// </summary>
	public class DefaultDirigente
	{
		private int _IDDirigente;
		private int _IDRuoloDirigenteInGara;
		private bool _Casa;

		/// <summary>
		/// Crea una nuova istanza della classe
		/// </summary>
		public DefaultDirigente()
		{
		}

		/// <summary>
		/// Legge le propriet� della classe dalla row
		/// </summary>
		/// <param name="row">Row da leggere</param>
		public void ReadFromRow(DataRow row)
		{
			_IDDirigente = General.DBToInt(row["IDDirigente"]);
			_IDRuoloDirigenteInGara = General.DBToInt(row["IDRuoloDirigenteInGara"]);
			_Casa = General.DBToBool(row["Casa"]);
		}

		/// <summary>
		/// Scrive le propriet� della classe nella row
		/// </summary>
		/// <param name="row">Row da scrivere</param>
		public void WriteToRow(DataRow row)
		{
			row["IDDirigente"] = General.IntToDB(_IDDirigente);
			row["IDRuoloDirigenteInGara"] = General.IntToDB(_IDRuoloDirigenteInGara);
			row["Casa"] = General.BoolToDB(_Casa);
		}

		/// <summary>
		/// Legge/Imposta IDDirigente
		/// </summary>
		public int IDDirigente
		{
			get
			{
				return _IDDirigente;
			}

			set
			{
				_IDDirigente = value;
			}
		}
		/// <summary>
		/// Legge/Imposta IDRuoloDirigenteInGara
		/// </summary>
		public int IDRuoloDirigenteInGara
		{
			get
			{
				return _IDRuoloDirigenteInGara;
			}

			set
			{
				_IDRuoloDirigenteInGara = value;
			}
		}
		/// <summary>
		/// Legge/Imposta Casa
		/// </summary>
		public bool Casa
		{
			get
			{
				return _Casa;
			}

			set
			{
				_Casa = value;
			}
		}
		/// <summary>
		/// Recupera l'hash code
		/// </summary>
		/// <param name="IDDirigente">IDDirigente</param>
		/// <param name="IDRuoloDirigenteInGara">IDRuoloDirigenteInGara</param>
		/// <param name="Casa">Casa</param>
		/// <returns>L'hash code</returns>
		public static int GetHashCode(int IDDirigente, int IDRuoloDirigenteInGara, bool Casa)
		{
			int hash = IDDirigente.GetHashCode();
			hash ^= IDRuoloDirigenteInGara.GetHashCode();
			hash ^= Casa.GetHashCode();

			return hash;
		}


		/// <summary>
		/// Confronta gli elementi
		/// </summary>
		/// <param name="a">Primo elemento</param>
		/// <param name="b">Secondo elemento</param>
		/// <returns>true se gli elementi sono uguali altrimenti false</returns>
		public static bool operator == (DefaultDirigente a, DefaultDirigente b)
		{
			if (object.Equals(a, null))
				return (object.Equals(b, null));
			else if (object.Equals(b, null))
				return false;
			else
				return (a._IDDirigente == b._IDDirigente && a._IDRuoloDirigenteInGara == b._IDRuoloDirigenteInGara && a._Casa == b._Casa);
		}

		/// <summary>
		/// Confronta gli elementi
		/// </summary>
		/// <param name="a">Primo elemento</param>
		/// <param name="b">Secondo elemento</param>
		/// <returns>true se gli elementi sono diversi altrimenti false</returns>
		public static bool operator != (DefaultDirigente a, DefaultDirigente b)
		{
			if (object.Equals(a, null))
				return (!object.Equals(b, null));
			else if (object.Equals(b, null))
				return true;
			else
				return !(a._IDDirigente == b._IDDirigente && a._IDRuoloDirigenteInGara == b._IDRuoloDirigenteInGara && a._Casa == b._Casa);
		}

		/// <summary>
		/// Confronta l'elemento corrente con l'elemento specificato
		/// </summary>
		/// <param name="obj">Oggetto da confrontare</param>
		/// <returns>true se gli elementi sono uguali altrimenti false</returns>
		public override bool Equals(object obj)
		{
			if (obj is DefaultDirigente)
			{
				DefaultDirigente DefaultDirigent = (DefaultDirigente) obj;
				return (DefaultDirigent._IDDirigente == this._IDDirigente && DefaultDirigent._IDRuoloDirigenteInGara == this._IDRuoloDirigenteInGara && DefaultDirigent._Casa == this._Casa);
			}

			return base.Equals(obj);
		}

		/// <summary>
		/// Recupera l'hash code
		/// </summary>
		/// <returns>L'hash code</returns>
		public override int GetHashCode()
		{
			return GetHashCode(_IDDirigente, _IDRuoloDirigenteInGara, _Casa);
		}
	}
}

